package com.dkd.manage.service.impl;

import java.util.List;
import com.dkd.common.utils.DateUtils;
import com.dkd.manage.domain.VendingMachine;
import com.dkd.manage.domain.dto.NodeQueryDto;
import com.dkd.manage.domain.vo.NodeVo;
import com.dkd.manage.domain.vo.RegionalDetailsVo;
import com.dkd.manage.mapper.VendingMachineMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.dkd.manage.mapper.NodeMapper;
import com.dkd.manage.domain.Node;
import com.dkd.manage.service.INodeService;
import org.springframework.transaction.annotation.Transactional;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 点位管理Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-09-02
 */
@Service
public class NodeServiceImpl implements INodeService 
{
    private static final Logger log = LoggerFactory.getLogger(NodeServiceImpl.class);
    
    @Autowired
    private NodeMapper nodeMapper;
    @Autowired
    private VendingMachineMapper vendingMachineMapper;

    /**
     * 查询点位管理
     * 
     * @param id 点位管理主键
     * @return 点位管理
     */
    @Override
    public Node selectNodeById(Long id)
    {
        return nodeMapper.selectNodeById(id);
    }

    /**
     * 查询点位管理列表
     * 
     * @param node 点位管理
     * @return 点位管理
     */
    @Override
    public List<Node> selectNodeList(Node node)
    {
        return nodeMapper.selectNodeList(node);
    }

    /**
     * 新增点位管理
     * 
     * @param node 点位管理
     * @return 结果
     */
    @Override
    public int insertNode(Node node)
    {
        node.setCreateTime(DateUtils.getNowDate());
        return nodeMapper.insertNode(node);
    }

    /**
     * 修改点位管理
     * 
     * @param node 点位管理
     * @return 结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int updateNode(Node node)
    {
        log.info("开始更新点位信息，点位ID: {}", node.getId());
        
        // 先更新点位表
        node.setUpdateTime(DateUtils.getNowDate());
        int result = nodeMapper.updateNode(node);
        
        if (result <= 0) {
            log.warn("点位更新失败，点位ID: {}", node.getId());
            return result;
        }
        
        log.info("点位表更新成功，开始同步设备表冗余字段，点位ID: {}", node.getId());
        
        // 更新设备管理页面的设备表的，关于点位表和设备表的外键关联的冗余字段
        // 获取设备管理表中使用到该点位id的设备id和设备信息，并更新设备管理表中的冗余字段
        VendingMachine query = new VendingMachine();
        query.setNodeId(node.getId());

        // 获取更新后的节点信息
        Node updatedNode = nodeMapper.selectNodeById(node.getId());
        if (updatedNode == null) {
            log.error("获取更新后的点位信息失败，点位ID: {}", node.getId());
            throw new RuntimeException("获取更新后的点位信息失败");
        }

        List<VendingMachine> vmList = vendingMachineMapper.selectVendingMachineList(query);
        log.info("找到 {} 台设备需要更新冗余字段，点位ID: {}", vmList.size(), node.getId());
        
        for (VendingMachine vm : vmList) {
            try {
                // 构建携带设备id和更新后的点位信息的参数
                VendingMachine updateVm = new VendingMachine();
                updateVm.setId(vm.getId());  // 设置设备ID
                // 设置需要更新的字段
                updateVm.setNodeId(node.getId());
                updateVm.setAddr(updatedNode.getAddress());
                updateVm.setBusinessType(updatedNode.getBusinessType());
                updateVm.setRegionId(updatedNode.getRegionId());
                updateVm.setPartnerId(updatedNode.getPartnerId());

                // 更新设备管理表
                int updateResult = vendingMachineMapper.updateVendingMachine(updateVm);
                if (updateResult > 0) {
                    log.debug("设备冗余字段更新成功，设备ID: {}, 点位ID: {}", vm.getId(), node.getId());
                } else {
                    log.warn("设备冗余字段更新失败，设备ID: {}, 点位ID: {}", vm.getId(), node.getId());
                }
            } catch (Exception e) {
                log.error("更新设备冗余字段时发生异常，设备ID: {}, 点位ID: {}, 错误信息: {}", 
                         vm.getId(), node.getId(), e.getMessage(), e);
                throw e; // 重新抛出异常，触发事务回滚
            }
        }
        
        log.info("点位更新完成，点位ID: {}, 同步了 {} 台设备的冗余字段", node.getId(), vmList.size());
        return result;
    }

    /**
     * 批量删除点位管理
     * 
     * @param ids 需要删除的点位管理主键
     * @return 结果
     */
    @Override
    public int deleteNodeByIds(Long[] ids)
    {
        return nodeMapper.deleteNodeByIds(ids);
    }

    /**
     * 删除点位管理信息
     * 
     * @param id 点位管理主键
     * @return 结果
     */
    @Override
    public int deleteNodeById(Long id)
    {
        return nodeMapper.deleteNodeById(id);
    }

    /**
     * 查询点位管理列表
     * 增加所在区域名称和合作商名称
     * @param node
     * @return
     */
    @Override
    public List<NodeVo> selectNodeVoList(NodeQueryDto node) {
        return nodeMapper.selectNodeVoList(node);
    }

    /**
     * 查询点位管理列表
     * 和区域管理的查看详情功能复用
     *
     * @param node
     * @return
     */
    @Override
    public List<RegionalDetailsVo> selectRegionalDetailsVoList(NodeQueryDto node) {
        List<RegionalDetailsVo> voList = nodeMapper.selectRegionalDetailsVoList(node);

        // 增加区域名称和合作商名称，为了优化后前端代码不需要修改
        voList.forEach(vo -> {
            vo.setRegionName(vo.getRegion().getRegionName());
            vo.setPartnerName(vo.getPartner().getPartnerName());
        });

        return voList;
    }
}
